{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "EMNIST Dense Classification",
      "provenance": [],
      "toc_visible": true,
      "authorship_tag": "ABX9TyMM1JrHf4QYvnGpuw/x4sCo",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/wandb/awesome-dl-projects/blob/master/ml-tutorial/EMNIST_Dense_Classification.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LHCCGutqrj-r",
        "colab_type": "text"
      },
      "source": [
        "# Imports and Setups"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qiFYfrVpXbAP",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 386
        },
        "outputId": "1d535337-0c58-4a6d-9af8-d18245cd6659"
      },
      "source": [
        "!nvidia-smi"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Tue Sep  8 01:41:50 2020       \n",
            "+-----------------------------------------------------------------------------+\n",
            "| NVIDIA-SMI 450.66       Driver Version: 418.67       CUDA Version: 10.1     |\n",
            "|-------------------------------+----------------------+----------------------+\n",
            "| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |\n",
            "| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |\n",
            "|                               |                      |               MIG M. |\n",
            "|===============================+======================+======================|\n",
            "|   0  Tesla T4            Off  | 00000000:00:04.0 Off |                    0 |\n",
            "| N/A   54C    P8    10W /  70W |      0MiB / 15079MiB |      0%      Default |\n",
            "|                               |                      |                 ERR! |\n",
            "+-------------------------------+----------------------+----------------------+\n",
            "                                                                               \n",
            "+-----------------------------------------------------------------------------+\n",
            "| Processes:                                                                  |\n",
            "|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |\n",
            "|        ID   ID                                                   Usage      |\n",
            "|=============================================================================|\n",
            "|  No running processes found                                                 |\n",
            "+-----------------------------------------------------------------------------+\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WwZMe8Ey0LYE",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 92
        },
        "outputId": "6d223b64-7236-4097-aa16-13cfb301ce43"
      },
      "source": [
        "import tensorflow as tf\n",
        "print(tf.__version__)\n",
        "\n",
        "from tensorflow.keras.layers import *\n",
        "from tensorflow.keras.models import *\n",
        "import tensorflow_datasets as tfds\n",
        "\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "%matplotlib inline\n",
        "tfds.disable_progress_bar()\n",
        "\n",
        "from tqdm import tqdm\n",
        "import seaborn as sns\n",
        "from sklearn.metrics import confusion_matrix\n",
        "from sklearn.preprocessing import normalize"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2.3.0\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/statsmodels/tools/_testing.py:19: FutureWarning: pandas.util.testing is deprecated. Use the functions in the public API at pandas.testing instead.\n",
            "  import pandas.util.testing as tm\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HqUfAaLR7H4F",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "%%capture\n",
        "!pip install wandb"
      ],
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3GeVDMnA7LOr",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 71
        },
        "outputId": "406efc7c-ca88-4302-a3d9-29148c55d80d"
      },
      "source": [
        "import wandb\n",
        "from wandb.keras import WandbCallback\n",
        "\n",
        "wandb.login()"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "application/javascript": [
              "\n",
              "        window._wandbApiKey = new Promise((resolve, reject) => {\n",
              "            function loadScript(url) {\n",
              "            return new Promise(function(resolve, reject) {\n",
              "                let newScript = document.createElement(\"script\");\n",
              "                newScript.onerror = reject;\n",
              "                newScript.onload = resolve;\n",
              "                document.body.appendChild(newScript);\n",
              "                newScript.src = url;\n",
              "            });\n",
              "            }\n",
              "            loadScript(\"https://cdn.jsdelivr.net/npm/postmate/build/postmate.min.js\").then(() => {\n",
              "            const iframe = document.createElement('iframe')\n",
              "            iframe.style.cssText = \"width:0;height:0;border:none\"\n",
              "            document.body.appendChild(iframe)\n",
              "            const handshake = new Postmate({\n",
              "                container: iframe,\n",
              "                url: 'https://app.wandb.ai/authorize'\n",
              "            });\n",
              "            const timeout = setTimeout(() => reject(\"Couldn't auto authenticate\"), 5000)\n",
              "            handshake.then(function(child) {\n",
              "                child.on('authorize', data => {\n",
              "                    clearTimeout(timeout)\n",
              "                    resolve(data)\n",
              "                });\n",
              "            });\n",
              "            })\n",
              "        });\n",
              "    "
            ],
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "\u001b[34m\u001b[1mwandb\u001b[0m: Appending key for api.wandb.ai to your netrc file: /root/.netrc\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "M_C6x2qUrnSu",
        "colab_type": "text"
      },
      "source": [
        "# Download EMNIST and Minor Investigation\n",
        "\n",
        "Check out this [colab notebook]() for:\n",
        "* More on `EMNIST/bymerge` dataset\n",
        "* Class distribution\n",
        "\n",
        "Check out [this paper](https://arxiv.org/abs/1702.05373) for more on EMNIST."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "T7KbDzcP0iXX",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 148
        },
        "outputId": "b27ce975-9532-4f8a-d505-5a1f3ba42218"
      },
      "source": [
        "# Gather EMNIST/bymerge dataset\n",
        "train_ds, validation_ds = tfds.load(\n",
        "    \"emnist/bymerge\",\n",
        "    split=[\"train[:85%]\", \"train[85%:]\"],\n",
        "    as_supervised=True\n",
        ")"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\u001b[1mDownloading and preparing dataset emnist/bymerge/3.0.0 (download: 535.73 MiB, generated: Unknown size, total: 535.73 MiB) to /root/tensorflow_datasets/emnist/bymerge/3.0.0...\u001b[0m\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/urllib3/connectionpool.py:847: InsecureRequestWarning: Unverified HTTPS request is being made. Adding certificate verification is strongly advised. See: https://urllib3.readthedocs.io/en/latest/advanced-usage.html#ssl-warnings\n",
            "  InsecureRequestWarning)\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "Shuffling and writing examples to /root/tensorflow_datasets/emnist/bymerge/3.0.0.incompleteMUINLI/emnist-train.tfrecord\n",
            "Shuffling and writing examples to /root/tensorflow_datasets/emnist/bymerge/3.0.0.incompleteMUINLI/emnist-test.tfrecord\n",
            "\u001b[1mDataset emnist downloaded and prepared to /root/tensorflow_datasets/emnist/bymerge/3.0.0. Subsequent calls will reuse this data.\u001b[0m\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QfFWriVto6G3",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "3e83d9fb-ae11-4daf-eb8c-5e5d7d1237ce"
      },
      "source": [
        "LABELS = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', \n",
        "          'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',\n",
        "          'a', 'b', 'd', 'e', 'f', 'g', 'h', 'n', 'q', 'r', 't']\n",
        "\n",
        "print(len(LABELS))"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "47\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6BNpPDFAruNE",
        "colab_type": "text"
      },
      "source": [
        "# Simple `tf.data` dataloader\n",
        "\n",
        "Check out TensorFlow's [tutorial](https://www.tensorflow.org/guide/data) on `tf.data`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kFzES4Xa2DTA",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "AUTO = tf.data.experimental.AUTOTUNE\n",
        "BATCH_SIZE = 256\n",
        "\n",
        "## We are transposing to rotate the image by 90 deg clockwise making the images human friendly.\n",
        "def transpose_and_flatten(image, label):\n",
        "  image = tf.image.convert_image_dtype(image, dtype=tf.float32) # scale image pixels to [0,1]\n",
        "  image = tf.transpose(image, [1,0,2]) # transpose to get human friendly image, since rotation\n",
        "  image = tf.reshape(image, shape=(784,)) # permutation invariant or flatten \n",
        "\n",
        "  label = tf.one_hot(label, depth=len(LABELS)) # one hot encode label\n",
        "\n",
        "  return image, label\n",
        "\n",
        "trainloader = (\n",
        "    train_ds\n",
        "    .shuffle(1024)\n",
        "    .map(transpose_and_flatten, num_parallel_calls=AUTO)\n",
        "    .batch(BATCH_SIZE)\n",
        "    .prefetch(AUTO)\n",
        ")\n",
        "\n",
        "testloader = (\n",
        "    validation_ds\n",
        "    .map(transpose_and_flatten, num_parallel_calls=AUTO)\n",
        "    .batch(BATCH_SIZE)\n",
        "    .prefetch(AUTO)\n",
        ")"
      ],
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0Il96w-6sCk9",
        "colab_type": "text"
      },
      "source": [
        "#### Quick Visualization\n",
        "(Run the cell below multiple times to visualize different images.)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0ekU0Gj3kU4c",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 591
        },
        "outputId": "c2b1ffc6-bc34-44ac-d831-c54cdc06a990"
      },
      "source": [
        "imgs, labels = next(iter(trainloader))\n",
        "\n",
        "plt.figure(figsize=(10, 10))\n",
        "for n in range(25):\n",
        "    ax = plt.subplot(5, 5, n+1)\n",
        "    plt.imshow(tf.reshape(imgs[n], shape=(28,28)), cmap='gray')\n",
        "    plt.title(LABELS[np.argmax(labels[n])])\n",
        "    plt.axis('off')"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 720x720 with 25 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dunhN6lbmjjy",
        "colab_type": "text"
      },
      "source": [
        "# Simple classifier"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YMkuvJKTm9dx",
        "colab_type": "text"
      },
      "source": [
        "#### Build Model"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "d5l1tnXhmmxH",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def DenseModel():\n",
        "  inputs = Input(shape=(784,))\n",
        "  x = Dense(256, activation='relu')(inputs)\n",
        "  x = Dense(128, activation='relu')(x)\n",
        "  outputs = Dense(len(LABELS), activation='softmax')(x)\n",
        "\n",
        "  return Model(inputs=inputs, outputs=outputs)"
      ],
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xwR4wZ99SPcP",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 312
        },
        "outputId": "56957727-4429-4cc7-e237-3e00475d17a0"
      },
      "source": [
        "tf.keras.backend.clear_session()\n",
        "model = DenseModel()\n",
        "model.summary()"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Model: \"functional_1\"\n",
            "_________________________________________________________________\n",
            "Layer (type)                 Output Shape              Param #   \n",
            "=================================================================\n",
            "input_1 (InputLayer)         [(None, 784)]             0         \n",
            "_________________________________________________________________\n",
            "dense (Dense)                (None, 256)               200960    \n",
            "_________________________________________________________________\n",
            "dense_1 (Dense)              (None, 128)               32896     \n",
            "_________________________________________________________________\n",
            "dense_2 (Dense)              (None, 47)                6063      \n",
            "=================================================================\n",
            "Total params: 239,919\n",
            "Trainable params: 239,919\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JxGdeZ_t6guC",
        "colab_type": "text"
      },
      "source": [
        "#### Callback"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JcglLPpt6jCk",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "early_stopper = tf.keras.callbacks.EarlyStopping(\n",
        "    monitor='val_loss', patience=5, verbose=0, mode='auto', restore_best_weights=True\n",
        ")"
      ],
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ScKH6S3HUhcu",
        "colab_type": "text"
      },
      "source": [
        "#### Train"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GSpEIbopSVQm",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 588
        },
        "outputId": "ac1e6748-0592-48fc-f079-b1b6dc0ab5eb"
      },
      "source": [
        "# initialize wandb run \n",
        "# do not change entity\n",
        "wandb.init(entity='iit-bhu', project='emnist')\n",
        "\n",
        "# hyperparameters\n",
        "config = wandb.config\n",
        "config.epochs = 70\n",
        "config.learning_rate = 0.001\n",
        "\n",
        "# model\n",
        "tf.keras.backend.clear_session()\n",
        "model = DenseModel()\n",
        "\n",
        "# optimizer\n",
        "optimizer = tf.keras.optimizers.Adam(learning_rate=config.learning_rate)\n",
        "\n",
        "# compile\n",
        "model.compile(optimizer, 'categorical_crossentropy', metrics=['acc'])\n",
        "\n",
        "# train\n",
        "model.fit(trainloader,\n",
        "          epochs=config.epochs,\n",
        "          validation_data=testloader,\n",
        "          callbacks=[WandbCallback(),\n",
        "                     early_stopper])"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/html": [
              "\n",
              "                Logging results to <a href=\"https://wandb.com\" target=\"_blank\">Weights & Biases</a> <a href=\"https://docs.wandb.com/integrations/jupyter.html\" target=\"_blank\">(Documentation)</a>.<br/>\n",
              "                Project page: <a href=\"https://app.wandb.ai/iit-bhu/emnist\" target=\"_blank\">https://app.wandb.ai/iit-bhu/emnist</a><br/>\n",
              "                Run page: <a href=\"https://app.wandb.ai/iit-bhu/emnist/runs/1szjcopa\" target=\"_blank\">https://app.wandb.ai/iit-bhu/emnist/runs/1szjcopa</a><br/>\n",
              "            "
            ],
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Epoch 1/70\n",
            "2318/2318 [==============================] - 127s 55ms/step - loss: 0.6052 - acc: 0.8121 - val_loss: 0.4265 - val_acc: 0.8560\n",
            "Epoch 2/70\n",
            "2318/2318 [==============================] - 127s 55ms/step - loss: 0.3909 - acc: 0.8663 - val_loss: 0.3810 - val_acc: 0.8676\n",
            "Epoch 3/70\n",
            "2318/2318 [==============================] - 122s 53ms/step - loss: 0.3519 - acc: 0.8768 - val_loss: 0.3611 - val_acc: 0.8749\n",
            "Epoch 4/70\n",
            "2318/2318 [==============================] - 127s 55ms/step - loss: 0.3296 - acc: 0.8829 - val_loss: 0.3525 - val_acc: 0.8769\n",
            "Epoch 5/70\n",
            "2318/2318 [==============================] - 128s 55ms/step - loss: 0.3135 - acc: 0.8872 - val_loss: 0.3504 - val_acc: 0.8773\n",
            "Epoch 6/70\n",
            "2318/2318 [==============================] - 127s 55ms/step - loss: 0.3018 - acc: 0.8909 - val_loss: 0.3486 - val_acc: 0.8785\n",
            "Epoch 7/70\n",
            "2318/2318 [==============================] - 127s 55ms/step - loss: 0.2918 - acc: 0.8933 - val_loss: 0.3488 - val_acc: 0.8785\n",
            "Epoch 8/70\n",
            "2318/2318 [==============================] - 127s 55ms/step - loss: 0.2840 - acc: 0.8954 - val_loss: 0.3483 - val_acc: 0.8801\n",
            "Epoch 9/70\n",
            "2318/2318 [==============================] - 126s 54ms/step - loss: 0.2770 - acc: 0.8973 - val_loss: 0.3530 - val_acc: 0.8764\n",
            "Epoch 10/70\n",
            "2318/2318 [==============================] - 127s 55ms/step - loss: 0.2715 - acc: 0.8991 - val_loss: 0.3568 - val_acc: 0.8784\n",
            "Epoch 11/70\n",
            "2318/2318 [==============================] - 123s 53ms/step - loss: 0.2658 - acc: 0.9001 - val_loss: 0.3556 - val_acc: 0.8799\n",
            "Epoch 12/70\n",
            "2318/2318 [==============================] - 127s 55ms/step - loss: 0.2613 - acc: 0.9016 - val_loss: 0.3588 - val_acc: 0.8801\n",
            "Epoch 13/70\n",
            "2318/2318 [==============================] - 128s 55ms/step - loss: 0.2572 - acc: 0.9027 - val_loss: 0.3606 - val_acc: 0.8809\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tensorflow.python.keras.callbacks.History at 0x7f12b86f6048>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5qbue1HNkX4-",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def plot_confusion_matrix():\n",
        "  y_test = []\n",
        "  y_preds = []\n",
        "  for imgs, labels in tqdm(testloader):\n",
        "      y_test.extend(np.argmax(labels, axis=1))\n",
        "      y_pred = model.predict(imgs)\n",
        "      y_preds.extend(np.argmax(y_pred, axis=1))\n",
        "\n",
        "  cm = confusion_matrix(y_true = y_test, y_pred = y_preds)\n",
        "  cm_normalize = normalize(cm, axis=1)\n",
        "\n",
        "  plt.figure(figsize=(15,15));\n",
        "  sns.heatmap(cm_normalize, annot=False, xticklabels=LABELS, yticklabels=LABELS, linewidths=.1);\n",
        "\n",
        "  plt.savefig('confusion_matrix.png', bbox_inches='tight')"
      ],
      "execution_count": 13,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wx6kPmjXv6F6",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 881
        },
        "outputId": "0cd7d8a2-ec5f-4b66-a9bc-e2c12392470c"
      },
      "source": [
        "plot_confusion_matrix()"
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "409it [00:29, 14.02it/s]\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1080x1080 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Uh6NuL1O0H48",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "wandb.log({\"image_confusion_matrix\": [wandb.Image('confusion_matrix.png')]})"
      ],
      "execution_count": 15,
      "outputs": []
    }
  ]
}